'use strict';

const crypto = require('crypto');

// 云对象名：user-service
module.exports = {
  /**
   * 用户注册
   * @param {object} params - 注册参数对象
   * @param {string} params.username - 用户名
   * @param {string} params.password - 密码
   * @param {string} params.phone - 手机号
   * @param {string} params.email - 邮箱
   * @param {string} params.nickname - 昵称
   * @param {string} params.realname - 真实姓名
   * @param {string} params.mobile - 手机号（兼容字段）
   * @returns {object} 注册结果
   */
  async register(params = {}) {
    try {
      // 获取数据库连接
      const db = uniCloud.database();
      const usersCollection = db.collection('users');
      
      // 从参数对象中解构
      const { username, password, phone, email, nickname, realname, mobile } = params;
      
      // 参数校验
      if (!password) {
        return {
          code: -1,
          message: '密码为必填项'
        };
      }
      
      // 确保有昵称
      if (!nickname) {
        return {
          code: -1,
          message: '昵称为必填项'
        };
      }
      
      // 确保有手机号和邮箱
      if (!phone && !mobile) {
        return {
          code: -1,
          message: '手机号为必填项'
        };
      }
      
      if (!email) {
        return {
          code: -1,
          message: '邮箱为必填项'
        };
      }
      
      // 检查用户名是否已存在
      if (username) {
        const existUser = await usersCollection.where({
          username: username
        }).get();
        
        if (existUser.data.length > 0) {
          return {
            code: -1,
            message: '用户名已存在'
          };
        }
      }
      
      // 检查手机号是否已存在
      if (phone || mobile) {
        const mobileToCheck = mobile || phone;
        const existPhone = await usersCollection.where({
          $or: [
            { phone: mobileToCheck },
            { mobile: mobileToCheck }
          ]
        }).get();
        
        if (existPhone.data.length > 0) {
          return {
            code: -1,
            message: '手机号已存在'
          };
        }
      }
      
      // 检查邮箱是否已存在
      if (email) {
        const existEmail = await usersCollection.where({
          email: email
        }).get();
        
        if (existEmail.data.length > 0) {
          return {
            code: -1,
            message: '邮箱已存在'
          };
        }
      }
      
      // 密码加密
      const md5Password = crypto.createHash('md5').update(password).digest('hex');
      
      // 创建用户，统一设置为普通用户
      const userData = {
        username: username || 'user_' + Date.now(),
        password: md5Password,
        phone: phone || mobile || '',
        mobile: mobile || phone || '',
        email: email || '',
        role: 0, // 统一设置为普通用户
        create_date: new Date(),
        status: 1, // 默认启用
        nickname: nickname // 设置昵称字段
      };
      
      // 创建用户
      const result = await usersCollection.add(userData);
      
      return {
        code: 0,
        message: '注册成功',
        data: {
          userId: result.id
        }
      };
    } catch (e) {
      console.error('注册失败：', e);
      return {
        code: -1,
        message: '注册失败，请稍后重试',
        error: e
      };
    }
  },

  /**
   * 用户登录
   * @param {object} params - 登录参数对象
   * @param {string} params.account - 账号（手机号或邮箱）
   * @param {string} params.password - 密码
   * @param {string} params.login_type - 登录类型（phone/email）
   * @param {string} params.device_id - 设备ID
   * @returns {object} 登录结果
   */
  async login(params = {}) {
    try {
      // 获取数据库连接
      const db = uniCloud.database();
      const usersCollection = db.collection('users');
      
      // 从参数对象中解构
      const { account, password, login_type = 'phone', device_id } = params;
      
      // 参数校验
      if (!account || !password) {
        return {
          code: -1,
          message: '账号和密码为必填项'
        };
      }
      
      // 密码加密
      const md5Password = crypto.createHash('md5').update(password).digest('hex');
      
      // 根据登录类型查询用户
      let whereCondition = {};
      
      switch (login_type) {
        case 'phone':
          whereCondition.phone = account;
          break;
        case 'email':
          whereCondition.email = account;
          break;
        default:
          return {
            code: -1,
            message: '不支持的登录类型'
          };
      }
      
      // 查询用户
      const userResult = await usersCollection.where(whereCondition).get();
      
      if (userResult.data.length === 0) {
        return {
          code: -1,
          message: '用户不存在'
        };
      }
      
      const user = userResult.data[0];
      
      // 验证密码
      if (user.password !== md5Password) {
        return {
          code: -1,
          message: '密码错误'
        };
      }
      
      // 检查用户状态
      if (user.status === 0) {
        return {
          code: -1,
          message: '账号已被禁用'
        };
      }
      
      // 生成token
      const token = 'token_' + Date.now() + '_' + user._id;
      const expire_time = Date.now() + (7 * 24 * 60 * 60 * 1000); // 7天后过期
      
      // 更新最后登录时间和token
      await usersCollection.doc(user._id).update({
        last_login_date: new Date(),
        token: token,
        expire_time: expire_time,
        device_id: device_id
      });
      
      // 返回用户信息
      return {
        code: 0,
        message: '登录成功',
        data: {
          _id: user._id,
          userId: user._id,
          username: user.username,
          nickname: user.nickname,
          phone: user.phone,
          email: user.email,
          role: user.role,
          status: user.status,
          token: token,
          expire_time: expire_time
        }
      };
    } catch (e) {
      console.error('登录失败：', e);
      return {
        code: -1,
        message: '登录失败，请稍后重试',
        error: e
      };
    }
  },

  /**
   * 微信登录
   * @param {object} params - 微信登录参数对象
   * @param {string} params.code - 微信授权码
   * @param {object} params.userInfo - 微信用户信息
   * @returns {object} 登录结果
   */
  async wechatLogin(params = {}) {
    try {
      const db = uniCloud.database();
      const usersCollection = db.collection('users');
      
      const { code, userInfo } = params;
      
      if (!code) {
        return {
          code: -1,
          message: 'code不能为空'
        };
      }
      
      // 简化的微信登录处理
      // 注：实际项目中这里应该调用微信API获取openid
      // 由于没有真实的微信API配置，这里返回暂不支持的提示
      return {
        code: -1,
        message: '微信登录功能暂时不可用，请使用账号密码登录'
      };
    } catch (e) {
      console.error('微信登录失败：', e);
      return {
        code: -1,
        message: '微信登录失败，请稍后重试',
        error: e
      };
    }
  },

  /**
   * 获取用户信息
   * @param {object} params - 参数对象
   * @param {string} params.token - 用户token
   * @returns {object} 用户信息
   */
  async getUserInfo(params = {}) {
    try {
      const db = uniCloud.database();
      
      const { token } = params;
      
      // 如果前端传入了token，优先使用token查询用户
      if (token) {
        console.log('使用token查询用户信息:', token);
        // 先通过token查询对应的用户ID，尝试多个可能的表
        let tokenResult = await db.collection('uni-id-users').where({
          token: token
        }).get();
        
        // 如果在uni-id-users表中没找到，尝试users表
        if (!tokenResult.data || tokenResult.data.length === 0) {
          console.log('在uni-id-users表中未找到，尝试users表');
          tokenResult = await db.collection('users').where({
            token: token
          }).get();
        }
        
        if (tokenResult.data && tokenResult.data.length > 0) {
          const userInfo = tokenResult.data[0];
          console.log('通过token找到用户ID:', userInfo._id);
          
          // 获取证书信息和状态
          let credentialInfo = null;
          let credentialStatus = userInfo.credential_status || null;
          
          if (userInfo.role === 1 || userInfo.role === 'referee') { // 裁判员
            const referee = await db.collection('referee_credentials').where({
              user_id: userInfo._id
            }).get();
            
            if (referee.data && referee.data.length > 0) {
              credentialInfo = referee.data[0];
              credentialStatus = credentialInfo.status || credentialStatus;
            }
          } else if (userInfo.role === 3 || userInfo.role === 'supervisor') { // 裁判监督
            const supervisor = await db.collection('supervisor_credentials').where({
              user_id: userInfo._id
            }).get();
            
            if (supervisor.data && supervisor.data.length > 0) {
              credentialInfo = supervisor.data[0];
              credentialStatus = credentialInfo.status || credentialStatus;
            }
          } else if (userInfo.role === 4 || userInfo.role === 'admin') { // 管理员
            const admin = await db.collection('admin_credentials').where({
              user_id: userInfo._id
            }).get();
            
            if (admin.data && admin.data.length > 0) {
              credentialInfo = admin.data[0];
              credentialStatus = credentialInfo.status || credentialStatus;
            }
          }
          
          // 构建返回结果
          const result = {
            _id: userInfo._id,
            userId: userInfo._id,
            username: userInfo.username || '',
            nickname: userInfo.nickname || '',
            real_name: userInfo.real_name || '',
            avatar: userInfo.avatar || '',
            phone: userInfo.phone || '',
            email: userInfo.email || '',
            role: userInfo.role || 0,
            status: userInfo.status || 1,
            create_date: userInfo.create_date || new Date(),
            last_login_date: userInfo.last_login_date || null,
            credential_status: credentialStatus,
            credential_type: userInfo.credential_type || null,
            referee_level: credentialInfo?.level || null
          };
          
          console.log('用户信息构建完成:', {
            userId: result._id,
            role: result.role,
            credential_status: result.credential_status,
            nickname: result.nickname
          });
          
          return {
            code: 0,
            message: '获取成功',
            data: result
          };
        } else {
          console.log('未找到与token匹配的用户');
          return {
            code: -1,
            message: 'token无效或已过期'
          };
        }
      }
      
      return {
        code: -1,
        message: '未找到用户信息'
      };
    } catch (e) {
      console.error('获取用户信息失败:', e);
      return {
        code: -1,
        message: '获取用户信息失败:' + e.message,
        error: e
      };
    }
  },

  /**
   * 保存用户配置
   * @param {object} params - 参数对象
   * @param {object} params.userInfo - 用户信息
   * @param {object} params.refereeInfo - 裁判信息
   * @param {object} params.adminInfo - 管理员信息
   * @param {string} params.token - 用户token
   * @returns {object} 保存结果
   */
  async saveUserProfile(params = {}) {
    try {
      const db = uniCloud.database();
      
      const { userInfo, refereeInfo, adminInfo, token } = params;
      
      // 参数校验
      if (!userInfo) {
        return {
          code: -1,
          message: '缺少用户信息'
        };
      }
      
      // 昵称必填验证
      if (!userInfo.nickname || userInfo.nickname.trim() === '') {
        return {
          code: -1,
          message: '姓名不能为空'
        };
      }
      
      // 获取当前用户的信息，验证身份
      let currentUser = null;
      
      // 如果有userInfo._id，尝试直接用它查询
      if (userInfo._id) {
        try {
          const userResult = await db.collection('users').doc(userInfo._id).get();
          if (userResult && userResult.data && userResult.data.length > 0) {
            currentUser = userResult.data[0];
          }
        } catch (e) {
          console.error('通过_id查询失败:', e);
        }
      }
      
      // 如果没找到，尝试通过token查询
      if (!currentUser && token) {
        const tokenResult = await db.collection('users').where({
          token: token
        }).limit(1).get();
        
        if (tokenResult && tokenResult.data && tokenResult.data.length > 0) {
          currentUser = tokenResult.data[0];
        }
      }
      
      // 如果无法获取用户信息，返回错误
      if (!currentUser) {
        return {
          code: -1,
          message: '未找到用户信息'
        };
      }
      
      // 构建更新对象，只更新允许的字段
      const updateData = {
        nickname: userInfo.nickname,
        realname: userInfo.nickname, // 将nickname同步到realname字段
        gender: userInfo.gender,
        birthday: userInfo.birthday,
        email: userInfo.email,
        mobile: userInfo.mobile,
        phone: userInfo.mobile, // 确保phone和mobile保持一致
        update_time: new Date().getTime()
      };
      
      // 如果有提供头像字段，则更新
      if (userInfo.avatar) {
        updateData.avatar = userInfo.avatar;
      }
      
      // 更新用户基本信息
      await db.collection('users').doc(currentUser._id).update(updateData);
      
      return {
        code: 0,
        message: '保存成功',
        data: {
          userId: currentUser._id
        }
      };
    } catch (e) {
      console.error('保存用户配置失败:', e);
      return {
        code: -1,
        message: '保存失败:' + e.message,
        error: e
      };
    }
  },

  /**
   * 更新用户状态
   * @param {object} params - 参数对象
   * @param {string} params.userId - 用户ID
   * @param {string} params.credential_status - 认证状态
   * @returns {object} 更新结果
   */
  async updateUserStatus(params = {}) {
    const db = uniCloud.database();
    
    const { userId, credential_status } = params;
    
    if (!userId) {
      return { code: -1, message: '缺少用户ID' };
    }
    
    try {
      // 更新用户状态
      await db.collection('users')
        .doc(userId)
        .update({
          credential_status: credential_status,
          update_time: new Date().getTime()
        });
      
      return {
        code: 0,
        message: '状态更新成功'
      };
    } catch (e) {
      console.error('更新用户状态失败:', e);
      return {
        code: -1,
        message: '更新失败: ' + e.message
      };
    }
  },

  /**
   * 修改密码
   * @param {object} params - 参数对象
   * @param {string} params.oldPassword - 原密码
   * @param {string} params.newPassword - 新密码
   * @param {object} params.userInfo - 用户信息
   * @param {string} params.token - 用户token
   * @returns {object} 修改结果
   */
  async changePassword(params = {}) {
    const db = uniCloud.database();
    const userCollection = db.collection('users');
    
    const { oldPassword, newPassword, userInfo, token } = params;
    
    // 参数校验
    if (!oldPassword || !newPassword) {
      return {
        code: 1,
        message: '参数不完整'
      };
    }
    
    // 获取当前用户
    let userId = null;
    
    // 1. 尝试从userInfo获取用户ID
    if (userInfo && userInfo._id) {
      userId = userInfo._id;
    }
    // 2. 尝试从token中获取用户信息
    else if (token) {
      try {
        const tokenResult = await db.collection('users').where({
          token: token
        }).get();
        
        if (tokenResult.data && tokenResult.data.length > 0) {
          userId = tokenResult.data[0]._id;
        }
      } catch (tokenError) {
        console.error('解析token失败:', tokenError);
      }
    }
    
    // 如果所有方法都无法获取到用户ID，返回错误
    if (!userId) {
      return {
        code: 2,
        message: '用户未登录或身份验证失败'
      };
    }
    
    try {
      // 查询用户信息
      const userResult = await userCollection.doc(userId).get();
      const user = userResult.data && userResult.data[0];
      
      if (!user) {
        return {
          code: 3,
          message: '用户不存在'
        };
      }
      
      // 校验原密码
      const oldPasswordHash = crypto.createHash('md5').update(oldPassword).digest('hex');
      if (user.password !== oldPasswordHash) {
        return {
          code: 4,
          message: '原密码错误'
        };
      }
      
      // 密码格式校验
      const passwordRegex = /^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,20}$/;
      if (!passwordRegex.test(newPassword)) {
        return {
          code: 5,
          message: '新密码必须为8-20位，包含字母和数字'
        };
      }
      
      // 生成新密码哈希
      const newPasswordHash = crypto.createHash('md5').update(newPassword).digest('hex');
      
      // 更新用户密码
      await userCollection.doc(userId).update({
        password: newPasswordHash,
        update_time: new Date().getTime()
      });
      
      // 记录密码修改日志
      await db.collection('password_change_logs').add({
        user_id: userId,
        ip: this.getClientInfo().clientIP || '未知IP',
        operation_time: new Date().getTime(),
        operation_type: 'change_password'
      });
      
      return {
        code: 0,
        message: '密码修改成功'
      };
    } catch (e) {
      console.error('修改密码错误:', e);
      return {
        code: 500,
        message: '服务器错误'
      };
    }
  },

  /**
   * 重置密码
   * @param {object} params - 参数对象
   * @param {string} params.userId - 用户ID
   * @param {string} params.newPassword - 新密码
   * @param {string} params.type - 重置类型
   * @returns {object} 重置结果
   */
  async resetPassword(params = {}) {
    const db = uniCloud.database();
    const userCollection = db.collection('users');
    
    const { userId, newPassword, type } = params;
    
    // 参数校验
    if (!userId || !newPassword || !type) {
      return {
        code: 1,
        message: '参数不完整'
      };
    }
    
    try {
      // 查询用户
      const userResult = await userCollection.doc(userId).get();
      
      if (userResult.data.length === 0) {
        return {
          code: 2,
          message: '用户不存在'
        };
      }
      
      // 密码格式校验
      const passwordRegex = /^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,20}$/;
      if (!passwordRegex.test(newPassword)) {
        return {
          code: 3,
          message: '密码必须为8-20位，包含字母和数字'
        };
      }
      
      // 生成新密码哈希
      const newPasswordHash = crypto.createHash('md5').update(newPassword).digest('hex');
      
      // 更新用户密码
      await userCollection.doc(userId).update({
        password: newPasswordHash,
        update_time: new Date().getTime()
      });
      
      // 记录密码重置日志
      await db.collection('password_change_logs').add({
        user_id: userId,
        ip: this.getClientInfo().clientIP,
        operation_time: new Date().getTime(),
        operation_type: 'reset_password',
        reset_type: type
      });
      
      return {
        code: 0,
        message: '密码重置成功'
      };
    } catch (e) {
      console.error('重置密码错误:', e);
      return {
        code: 500,
        message: '服务器错误'
      };
    }
  },

  /**
   * 刷新token
   * @param {object} params - 参数对象
   * @param {string} params.token - 当前token
   * @returns {object} 刷新结果
   */
  async refreshToken(params = {}) {
    const { token } = params;
    
    console.log('刷新token，参数:', token);
    
    if (!token) {
      console.log('未提供token');
      return {
        code: -1,
        message: '未提供有效的token'
      };
    }
    
    try {
      const db = uniCloud.database();
      
      // 通过token查找用户
      const userResult = await db.collection('users').where({
        token: token
      }).get();
      
      if (userResult.data.length === 0) {
        return {
          code: -1,
          message: 'token无效'
        };
      }
      
      const user = userResult.data[0];
      
      // 生成新的token
      const crypto = require('crypto');
      const newToken = crypto.randomBytes(32).toString('hex');
      const newExpireTime = Date.now() + (7 * 24 * 60 * 60 * 1000); // 7天
      
      // 更新用户token
      await db.collection('users').doc(user._id).update({
        token: newToken,
        expire_time: newExpireTime,
        update_time: Date.now()
      });
      
      console.log('token刷新成功');
      
      return {
        code: 0,
        message: 'token刷新成功',
        data: {
          token: newToken,
          expire_time: newExpireTime
        }
      };
    } catch (error) {
      console.error('刷新token出错:', error);
      return {
        code: -2,
        message: '无法刷新token: ' + error.message
      };
    }
  },

  /**
   * 验证token
   * @param {object} params - 参数对象
   * @param {string} params.token - 要验证的token
   * @param {string} params.userId - 用户ID（可选）
   * @returns {object} 验证结果
   */
  async verifyToken(params = {}) {
    const { token, userId } = params;
    
    // 参数验证
    if (!token) {
      return {
        code: -1,
        message: 'token不能为空'
      };
    }
    
    try {
      // 获取数据库引用
      const db = uniCloud.database();
      const usersCollection = db.collection('users');
      
      // 查询条件
      let queryCondition = { token };
      
      // 如果提供了userId，增加到查询条件中
      if (userId) {
        queryCondition._id = userId;
      }
      
      // 查询用户
      const userResult = await usersCollection.where(queryCondition).get();
      
      // 判断是否找到用户
      if (userResult.data.length === 0) {
        return {
          code: -1,
          message: 'token无效或已过期'
        };
      }
      
      // token有效
      return {
        code: 0,
        message: 'token有效',
        data: {
          userId: userResult.data[0]._id
        }
      };
    } catch (e) {
      console.error('验证token失败：', e);
      return {
        code: -1,
        message: '验证token失败，服务器异常',
        error: e
      };
    }
  },

  /**
   * 身份验证
   * @param {object} params - 参数对象
   * @param {string} params.phone - 手机号
   * @param {string} params.email - 邮箱
   * @param {string} params.verifyCode - 验证码
   * @param {string} params.type - 验证类型
   * @returns {object} 验证结果
   */
  async verifyIdentity(params = {}) {
    const db = uniCloud.database();
    const userCollection = db.collection('users');
    const verifyCodeCollection = db.collection('verify_codes');
    
    const { phone, email, verifyCode, type } = params;
    
    // 参数校验
    if ((!phone && !email) || !verifyCode || !type) {
      return {
        code: 1,
        message: '参数不完整'
      };
    }
    
    try {
      // 查询验证码
      const target = phone || email;
      const verifyResult = await verifyCodeCollection.where({
        target: target,
        type: type,
        status: 0, // 未使用
        expire_time: db.command.gt(Date.now())
      }).orderBy('create_time', 'desc').limit(1).get();
      
      if (verifyResult.data.length === 0) {
        return {
          code: 2,
          message: '验证码不存在或已过期，请重新获取'
        };
      }
      
      const verifyRecord = verifyResult.data[0];
      
      // 验证码是否匹配
      if (verifyRecord.code !== verifyCode) {
        return {
          code: 3,
          message: '验证码错误'
        };
      }
      
      // 查询用户
      let userQuery = {};
      if (phone) {
        userQuery.mobile = phone;
      } else if (email) {
        userQuery.email = email;
      }
      
      const userResult = await userCollection.where(userQuery).get();
      
      if (userResult.data.length === 0) {
        return {
          code: 4,
          message: '用户不存在'
        };
      }
      
      const user = userResult.data[0];
      
      // 标记验证码为已使用
      await verifyCodeCollection.doc(verifyRecord._id).update({
        status: 1, // 已使用
        use_time: Date.now(),
        use_ip: this.getClientInfo().clientIP
      });
      
      // 记录验证日志
      await db.collection('verification_logs').add({
        user_id: user._id,
        type: type,
        target: target,
        ip: this.getClientInfo().clientIP,
        verify_time: Date.now(),
        verify_result: true
      });
      
      return {
        code: 0,
        message: '验证成功',
        data: {
          userId: user._id
        }
      };
    } catch (e) {
      console.error('验证身份错误:', e);
      return {
        code: 500,
        message: '服务器错误'
      };
    }
  },

  /**
   * 用户退出登录
   * @param {object} params - 参数对象
   * @param {string} params.token - 用户token
   * @param {string} params.device_id - 设备ID
   * @returns {object} 退出结果
   */
  async logout(params = {}) {
    try {
      const db = uniCloud.database();
      
      const { token, device_id } = params;
      
      if (!token) {
        return {
          code: -1,
          message: '缺少token参数'
        };
      }
      
      // 查找并清除用户的token
      const result = await db.collection('users').where({
        token: token
      }).update({
        token: null,
        device_id: null,
        last_logout_date: new Date(),
        update_time: new Date()
      });
      
      return {
        code: 0,
        message: '退出成功',
        data: {
          affected: result.updated
        }
      };
    } catch (e) {
      console.error('退出登录失败:', e);
      return {
        code: -1,
        message: '退出登录失败: ' + e.message
      };
    }
  },

  /**
   * 搜索用户（邀请功能专用）
   * @param {object} params - 搜索参数
   * @param {string} params.keyword - 搜索关键词（姓名、手机号）
   * @param {number} params.level - 裁判等级筛选
   * @param {string} params.region - 地区筛选
   * @param {string} params.association - 协会筛选
   * @param {number} params.page - 页码
   * @param {number} params.limit - 每页数量
   * @returns {object} 搜索结果
   */
  async searchUsersForInvitation(params = {}) {
    try {
      const { keyword, level, region, organization, page = 1, limit = 20 } = params;
      
      // 验证token
      const token = this.getUniIdToken();
      if (!token) {
        return {
          code: -1,
          message: '未登录或登录状态已过期'
        };
      }

      const db = uniCloud.database();
      
      // 验证token有效性
      const tokenResult = await db.collection('users').where({
        token: token,
        status: 1
      }).get();
      
      if (!tokenResult.data || tokenResult.data.length === 0) {
        return {
          code: -1,
          message: '身份验证失败'
        };
      }

      const usersCollection = db.collection('users');
      
      // 构建用户查询条件
      let userWhere = { 
        status: 1, // 只查询活跃用户
        role: db.command.in([1, 3]) // 只查询裁判员和裁判监督
      };
      
      // 关键词搜索
      if (keyword && keyword.trim()) {
        const keywordTrim = keyword.trim();
        userWhere.$or = [
          { real_name: new RegExp(keywordTrim, 'i') },
          { nickname: new RegExp(keywordTrim, 'i') },
          { username: new RegExp(keywordTrim, 'i') },
          { phone: keywordTrim },
          { mobile: keywordTrim }
        ];
      }

      const skip = (page - 1) * limit;
      
      // 查询用户基础信息 - 查询更多字段以确保数据完整
      const usersResult = await usersCollection
        .where(userWhere)
        .field({
          _id: true,
          real_name: true,
          nickname: true,
          username: true,
          phone: true,
          mobile: true,
          role: true
        })
        .skip(skip)
        .limit(limit)
        .get();

      if (usersResult.data.length === 0) {
        return {
          code: 0,
          message: '搜索成功',
          data: {
            users: [],
            total: 0,
            page: page,
            limit: limit,
            hasMore: false
          }
        };
      }

      // 获取用户的资质信息
      const userIds = usersResult.data.map(user => user._id);
      const credentialsCollection = db.collection('referee_credentials');
      
      let credentialWhere = {
        user_id: db.command.in(userIds),
        status: 'approved'
      };

      // 等级筛选 - 将等级名称转换为数字
      if (level && level.trim() && level !== '全部') {
        const levelMap = {
          '国际级': 6,
          '国家级': 5,
          '预备国家级': 4,
          '一级': 3,
          '二级': 2,
          '三级': 1
        };
        const levelNum = levelMap[level.trim()];
        if (levelNum) {
          credentialWhere.level = levelNum;
        }
      }

      // 协会/组织筛选 - 在credentials表中进行筛选
      if (organization && organization.trim() && organization !== '全部') {
        credentialWhere.register_organization = new RegExp(organization.trim(), 'i');
      }
      
      // 如果有地区筛选，也在register_organization中查找
      if (region && region.trim() && region !== '全部') {
        if (credentialWhere.register_organization) {
          // 如果已经有协会筛选，需要同时满足协会和地区条件
          credentialWhere.$and = [
            { register_organization: credentialWhere.register_organization },
            { register_organization: new RegExp(region.trim(), 'i') }
          ];
          delete credentialWhere.register_organization;
        } else {
          credentialWhere.register_organization = new RegExp(region.trim(), 'i');
        }
      }

      const credentialsResult = await credentialsCollection
        .where(credentialWhere)
        .field({
          user_id: true,
          level: true,
          register_organization: true
        })
        .get();

      // 创建资质映射
      const credentialMap = {};
      credentialsResult.data.forEach(credential => {
        credentialMap[credential.user_id] = credential;
      });

      // 保存this引用，避免在map中丢失上下文
      const self = this;
      
      // 定义等级名称映射函数，避免this上下文问题
      const getLevelName = (level) => {
        const levelMap = {
          1: '三级',
          2: '二级', 
          3: '一级',
          4: '预备国家级',
          5: '国家级',
          6: '国际级'
        };
        return levelMap[level] || '未认证';
      };
      
      // 处理结果数据，只保留有匹配资质的用户
      const userList = usersResult.data
        .filter(user => credentialMap[user._id]) // 只保留有匹配资质的用户
        .map(user => {
          const credential = credentialMap[user._id] || {};
          
          // 计算匹配度分数
          let matchScore = 50; // 基础分数
          
          // 关键词匹配度
          if (keyword && keyword.trim()) {
            const keywordLower = keyword.toLowerCase();
            if (user.real_name?.toLowerCase().includes(keywordLower)) matchScore += 20;
            if (user.phone?.includes(keyword)) matchScore += 15;
            if (user.mobile?.includes(keyword)) matchScore += 15;
          }
          
          // 等级匹配度
          if (level && level !== '全部') {
            const levelMap = {
              '国际级': 6,
              '国家级': 5,
              '预备国家级': 4,
              '一级': 3,
              '二级': 2,
              '三级': 1
            };
            const levelNum = levelMap[level.trim()];
            if (levelNum && credential.level === levelNum) matchScore += 15;
          }
          
          // 地区匹配度 - 基于register_organization
          if (region && region !== '全部' && credential.register_organization?.includes(region)) matchScore += 10;
          
          // 协会匹配度
          if (organization && organization !== '全部' && credential.register_organization?.includes(organization)) matchScore += 10;
          
          // 确保分数不超过100
          matchScore = Math.min(matchScore, 100);

          // 优先使用 real_name，然后是 nickname，最后是 username
          const displayName = user.real_name || user.nickname || user.username || '未设置';

          return {
            _id: user._id,
            nickname: displayName, // 显示名称
            real_name: user.real_name || displayName,
            phone: user.phone || user.mobile || '未填写',
            region: credential.register_organization || '未设置', // 使用注册单位作为地区显示
            level: credential.level || 0,
            level_name: getLevelName(credential.level || 0),
            association: credential.register_organization || '未设置',
            matchScore: matchScore
          };
        });
      
      // 按匹配度排序
      userList.sort((a, b) => b.matchScore - a.matchScore);

      return {
        code: 0,
        message: '搜索成功',
        data: {
          users: userList,
          total: userList.length,
          page: page,
          limit: limit,
          hasMore: userList.length === limit
        }
      };

    } catch (error) {
      console.error('搜索用户失败:', error);
      return {
        code: -1,
        message: '搜索用户失败: ' + error.message
      };
    }
  },

  /**
   * 获取等级名称
   * @param {number} level - 等级数字
   * @returns {string} 等级名称
   */
  getLevelName(level) {
    const levelMap = {
      1: '三级',
      2: '二级', 
      3: '一级',
      4: '预备国家级',
      5: '国家级',
      6: '国际级'
    };
    return levelMap[level] || '未认证';
  },

  /**
   * 获取筛选选项（邀请功能专用）
   * @returns {object} 筛选选项数据
   */
  async getFilterOptions() {
    try {
      // 验证token
      const token = this.getUniIdToken();
      if (!token) {
        return {
          code: -1,
          message: '未登录或登录状态已过期'
        };
      }

      const db = uniCloud.database();
      
      // 验证token有效性
      const tokenResult = await db.collection('users').where({
        token: token,
        status: 1
      }).get();
      
      if (!tokenResult.data || tokenResult.data.length === 0) {
        return {
          code: -1,
          message: '身份验证失败'
        };
      }

      // 从 referee_credentials 表获取所有组织选项
      const credentialsCollection = db.collection('referee_credentials');
      const credentialsResult = await credentialsCollection
        .where({
          status: 'approved'
        })
        .field({
          register_organization: true
        })
        .get();

      // 提取所有不重复的组织名称
      const organizationsSet = new Set();
      const regionsSet = new Set();

      credentialsResult.data.forEach(credential => {
        if (credential.register_organization && credential.register_organization.trim()) {
          const org = credential.register_organization.trim();
          organizationsSet.add(org);
          
          // 简单提取地区信息（假设组织名称包含地区信息）
          // 如：北京市足球协会 -> 北京市
          const regionMatch = org.match(/^([^市省区县]*[市省区县])/);
          if (regionMatch) {
            regionsSet.add(regionMatch[1]);
          }
        }
      });

      // 转换为数组并排序
      const organizations = Array.from(organizationsSet).sort();
      const regions = Array.from(regionsSet).sort();

      return {
        code: 0,
        message: '获取成功',
        data: {
          organizations: organizations,
          regions: regions
        }
      };

    } catch (error) {
      console.error('获取筛选选项失败:', error);
      return {
        code: -1,
        message: '获取筛选选项失败: ' + error.message
      };
    }
  }
}; 